package thread;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 74646
 * Date: 2022-04-30
 * Time: 11:00
 */

/**
 * 线程不安全的典型案例：
 * 使用两个线程，对同一个整型变量进行自增操作
 * 每个线程自增5万次，看最终的结果
 */

// 这个类是实现变量自增
class Counter{
    // 这个变量就是两个线程要自增的变量
    public int count;
    // 解决方法：对变量自增的 increase 方法加一个 synchronized 修饰（加锁）
   // synchronized
   synchronized public void increase(){
        count++;
    }
}

public class TestDemo21 {
   public static Counter counter = new Counter();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                // 自增操作
                counter.increase();
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                // 自增操作
                counter.increase();
            }
        });
        t1.start();
        t2.start();

        /**
         * 因为 main 线程与 t1,t2 线程是并发执行的，会导致 t1,t2 线程还没执行完就执行下面的打印操作
         * 为了保证 t1,t2 线程都执行完了再打印 count，
         * 所以调用 join 方法，等待 t1,t2 线程都执行完了再打印
         */
        try {
            // 这两个 join 的先后顺序是无所谓的
            // 由于线程调度是随机的，所以不确定 t1 和 t2 谁先结束
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 在 main 方法中打印两个线程自增完之后的结果
        System.out.println(counter.count);
    }
}
